package com.rongshu.api;

import com.rongshu.base.BuildConfig;
import com.rongshu.utils.Common;
import com.rongshu.view.base.mvp.INetBean;
import com.rongshu.view.discovery.bean.ArticleDetailsResponse;
import com.rongshu.view.discovery.bean.ArticleListResponse;
import com.rongshu.view.discovery.bean.EventListResponse;
import com.rongshu.view.discovery.bean.IsAtUserBlackResponse;
import com.rongshu.view.discovery.bean.SearchAllResponse;
import com.rongshu.view.discovery.bean.SearchAuthorResponse;
import com.rongshu.view.discovery.bean.SearchBody;
import com.rongshu.view.discovery.bean.SerialChapterListResponse;
import com.rongshu.view.discovery.bean.SerialListResponse;
import com.rongshu.view.discovery.bean.UserInfoResponse;
import com.rongshu.view.home.bean.AdvertResponse;
import com.rongshu.view.home.bean.BannerResponse;
import com.rongshu.view.home.bean.LabelResponse;
import com.rongshu.view.home.bean.RecommendAuthorResponse;
import com.rongshu.view.home.bean.RecommendEditResponse;
import com.rongshu.view.home.bean.RecommendReaderResponse;
import com.rongshu.view.home.bean.VersionUpdateResponse;
import com.rongshu.view.home.entity.ArticleAttribute;
import com.rongshu.view.home.entity.ArticleDetails;
import com.rongshu.view.home.entity.ArticleLike;
import com.rongshu.view.home.entity.CatalogInfo;
import com.rongshu.view.home.entity.CommenOneAllDetails;
import com.rongshu.view.home.entity.CommentDetails;
import com.rongshu.view.home.entity.ContentClass;
import com.rongshu.view.home.entity.DaySignDetailsResponse;
import com.rongshu.view.home.entity.DaySignInfo;
import com.rongshu.view.home.entity.DaySignListResponse;
import com.rongshu.view.home.entity.MakeDaySignBody;
import com.rongshu.view.home.entity.PenpalHomeResponse;
import com.rongshu.view.home.entity.PeopleRecommendRespose;
import com.rongshu.view.home.entity.RecomendMsg;
import com.rongshu.view.home.entity.RecommendClass;
import com.rongshu.view.home.entity.RecommendResponse;
import com.rongshu.view.home.entity.ShareInformation;
import com.rongshu.view.home.entity.UserAttention;
import com.rongshu.view.home.entity.UserCollect;
import com.rongshu.view.home.entity.UserInfo;
import com.rongshu.view.home.entity.UserProps;
import com.rongshu.view.login.entity.LoginQuestion;
import com.rongshu.view.login.entity.PasswordLogin;
import com.rongshu.view.login.entity.PerfectPenName;
import com.rongshu.view.login.entity.QuestionFeedback;
import com.rongshu.view.login.entity.ReportClass;
import com.rongshu.view.login.entity.ResetPassword;
import com.rongshu.view.login.entity.ThirdPartyClass;
import com.rongshu.view.login.entity.UpLoadFile;
import com.rongshu.view.login.entity.UpdateUserClass;
import com.rongshu.view.login.entity.VerificationCode;
import com.rongshu.view.mediaPlayer.bean.AudiobookDetailsResponse;
import com.rongshu.view.mediaPlayer.bean.AudiobookListResponse;
import com.rongshu.view.penpal.bean.AddNoticeBody;
import com.rongshu.view.penpal.bean.ArticleColumnsResponse;
import com.rongshu.view.penpal.bean.ArticleLabelsResponse;
import com.rongshu.view.penpal.bean.EditNoticeBody;
import com.rongshu.view.penpal.bean.EditPenpalMsgBody;
import com.rongshu.view.penpal.bean.MemberMsgResponse;
import com.rongshu.view.penpal.bean.PenpalArticleResponse;
import com.rongshu.view.penpal.bean.PenpalDetailsResponse;
import com.rongshu.view.penpal.bean.PenpalJoinVerifyResponse;
import com.rongshu.view.penpal.bean.PenpalMessageResponse;
import com.rongshu.view.penpal.bean.PenpalNoticeResponse;
import com.rongshu.view.penpal.bean.PenpalRecommendArticleResponse;
import com.rongshu.view.penpal.bean.PenpalResponse;
import com.rongshu.view.penpal.bean.PostCommentBody;
import com.rongshu.view.penpal.bean.PostDetailsResponse;
import com.rongshu.view.submitArticle.bean.DraftResponse;
import com.rongshu.view.submitArticle.bean.SavaDraftBody;
import com.rongshu.view.submitArticle.bean.SaveDraftResponse;
import com.rongshu.view.submitArticle.bean.SubmitArticleBody;
import com.rongshu.view.submitArticle.bean.SubmitPostBody;
import com.rongshu.view.userInfo.entity.AboutUs;
import com.rongshu.view.userInfo.entity.AccountInformation;
import com.rongshu.view.userInfo.entity.Article;
import com.rongshu.view.userInfo.entity.AtMineMessage;
import com.rongshu.view.userInfo.entity.CardBagInfo;
import com.rongshu.view.userInfo.entity.City;
import com.rongshu.view.userInfo.entity.CollectedArticle;
import com.rongshu.view.userInfo.entity.CollectedWorkStatusCount;
import com.rongshu.view.userInfo.entity.CommentMeMessage;
import com.rongshu.view.userInfo.entity.DirectChat;
import com.rongshu.view.userInfo.entity.DirectMessage;
import com.rongshu.view.userInfo.entity.EnshrineInfo;
import com.rongshu.view.userInfo.entity.GiveLikeMessage;
import com.rongshu.view.userInfo.entity.MessageInfo;
import com.rongshu.view.userInfo.entity.OrderInfo;
import com.rongshu.view.userInfo.entity.PayDetail;
import com.rongshu.view.userInfo.entity.PaySetMeal;
import com.rongshu.view.userInfo.entity.PostVipAuthentication;
import com.rongshu.view.userInfo.entity.PrivacyInfo;
import com.rongshu.view.userInfo.entity.Province;
import com.rongshu.view.userInfo.entity.Recommend;
import com.rongshu.view.userInfo.entity.RecyclerStationInfo;
import com.rongshu.view.userInfo.entity.SignDayResponse;
import com.rongshu.view.userInfo.entity.SignInBody;
import com.rongshu.view.userInfo.entity.SignListResponse;
import com.rongshu.view.userInfo.entity.SystemMessage;
import com.rongshu.view.userInfo.entity.ThirdPartyInfo;
import com.rongshu.view.userInfo.entity.TodayRecord;
import com.rongshu.view.userInfo.entity.sixinClass;

import java.util.List;
import java.util.concurrent.TimeUnit;

import okhttp3.OkHttpClient;
import okhttp3.ResponseBody;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;
import rx.Observable;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;

public class RetorfitService {

    private static INewsApi sNewsService;

    private RetorfitService() {
        throw new AssertionError();
    }

    public static void init() {
        LoggingInterceptor loggingInterceptor = new LoggingInterceptor();
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        if (BuildConfig.IS_DEBUG) {
            builder.addInterceptor(loggingInterceptor);
        }
        OkHttpClient okHttpClient = builder
                .retryOnConnectionFailure(true)
                .connectTimeout(10, TimeUnit.SECONDS)
                .readTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .build();

        Retrofit retrofit = new Retrofit.Builder()
                .client(okHttpClient)
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .baseUrl(Common.PRO_HOST)
                .build();
        sNewsService = retrofit.create(INewsApi.class);
    }

    /**
     * 获取手机验证码
     */
    public static Observable<VerificationCode> getPhoneVerficationCode(String mobile, int type, String sign) {
        return sNewsService.getPhoneVerficationCode(mobile, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 用户手机号和短信验证码登陆
     */
    public static Observable<PasswordLogin> getUserRegisterforMobileCode(String mobile, String code, String registrationid, String sign) {
        return sNewsService.getUserRegisterforMobileCode(mobile, code, registrationid, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取文章详情
     */
    public static Observable<ArticleDetails> getPostDetail(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getPostDetail(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 忘记密码
     */
    public static Observable<ResetPassword> postResetPassword(String mobile, String sms_code,
                                                              String sign, UpdateUserClass updateUserClass) {
        return sNewsService.postResetPassword(mobile, sms_code, sign, updateUserClass)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 通过手机号码，密码登陆
     */
    public static Observable<PasswordLogin> getUserRegisterforMobilePwd(String mobile, String pwd, String registrationid, String sign) {
        return sNewsService.getUserRegisterforMobilePwd(mobile, pwd, registrationid, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取登录遇到的问题
     */
    public static Observable<LoginQuestion> getLoginProblems(int rnd, String sign) {
        return sNewsService.getLoginProblems(rnd, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 1反馈2举报用户/3举报文章/4举报贴子
     */
    public static Observable<QuestionFeedback> postReportUser(int user_id, int type, int user_id_to,
                                                              int reporttype, String sign, ReportClass reportClass) {
        return sNewsService.postReportUser(user_id, type, user_id_to, reporttype, sign, reportClass)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取省份
     */
    public static Observable<Province> getChinaAddr(String rnd, String sign) {
        return sNewsService.getChinaAddr(rnd, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }


    /**
     * 获取city
     */
    public static Observable<City> getCity(int parent_id, String sign) {
        return sNewsService.getCity(parent_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取banner
     */
    public static Observable<BannerResponse> getBanner(int user_id, String sign) {
        return sNewsService.getBanner(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取发现页面-推荐读者
     */
    public static Observable<RecommendAuthorResponse> getRecommendAuthor(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getRecommendAuthors(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取发现页面-编辑推荐
     */
    public static Observable<RecommendEditResponse> getRecommendEdit(int user_id, String sign) {
        return sNewsService.getRecommentEdits(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取推荐语
     */
    public static Observable<RecomendMsg> getRecommendMsg(int contribute_id, int contribute_type, int pageIndex, int pageSize, String sign) {
        return sNewsService.getRecommendMsg(contribute_id, contribute_type, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取发现页面-读者推荐
     */
    public static Observable<RecommendReaderResponse> getRecommendReader(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getRecommentReader(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 关注
     */
    public static Observable<INetBean> ConcernWith(int user_id, int contribute_id, int user_id_to, String sign) {
        return sNewsService.ConcernWith(user_id, contribute_id, user_id_to, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 取消关注
     */
    public static Observable<INetBean> cancelConcernWith(int user_id, int contribute_id, int user_id_to, String sign) {
        return sNewsService.cancelConcernWith(user_id, contribute_id, user_id_to, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取我是否关注过某一个用户
     */
    public static Observable<UserAttention> getIsGuanZhu(int user_id, int ta_user_id, String sign) {
        return sNewsService.getIsGuanZhu(user_id, ta_user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取标签
     */
    public static Observable<LabelResponse> getlabel(int rnd, int type, String sign) {
        return sNewsService.getLabels(rnd, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取关键字标签
     */
    public static Observable<LabelResponse> getSearchRecommendLabel(int user_id, int type, String sign) {
        return sNewsService.getSearchRecommendLabel(user_id, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 综合搜索
     */
    public static Observable<SearchAllResponse> searchAll(int user_id, int pageIndex, int pageSize, String sign, SearchBody body) {
        return sNewsService.searchAll(user_id, pageIndex, pageSize, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 文章搜索
     */
    public static Observable<ArticleListResponse> searchArticle(int user_id, int pageIndex, int pageSize, String sign, SearchBody body) {
        return sNewsService.searchArticle(user_id, pageIndex, pageSize, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 用户搜索
     */
    public static Observable<SearchAuthorResponse> searchAuthor(int user_id, int pageIndex, int pageSize, String sign, SearchBody body) {
        return sNewsService.searchAuthor(user_id, pageIndex, pageSize, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 编辑推荐(根据传入编辑推荐模板ID获取不同的数据)
     */
    public static Observable<ArticleListResponse> getArticleListById(int user_id, int Templates_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getArticleListById(user_id, Templates_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 单个文章详情
     */
    public static Observable<ArticleDetailsResponse> getAiticleDetails(int user_id, int contribute_id, int contribute_type, int type, int topic_id, String sign) {
        return sNewsService.getArticleDetails(user_id, contribute_id, contribute_type, type, topic_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取他人主页
     */
    public static Observable<UserInfoResponse> getOtherUserInfo(int user_id, int user_id_to, String sign) {
        return sNewsService.getOtherUserInfo(user_id, user_id_to, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())

                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 将指定的用户加入我的黑名单/移除黑名单
     */
    public static Observable<Object> blackListOption(int user_id, int user_id_to, String sign) {
        return sNewsService.blackListOption(user_id, user_id_to, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 完善笔名
     */
    public static Observable<INetBean> perfectPanName(int user_id, String sign, PerfectPenName perfectPenName) {
        return sNewsService.perfectPanName(user_id, sign, perfectPenName)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 保存草稿
     */
    public static Observable<SaveDraftResponse> saveDraft(int user_id, int serial_id, int cg_id, int number, String sign, SavaDraftBody body) {
        return sNewsService.saveDraft(user_id, cg_id, serial_id, number, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * APP投稿设置-选择文章栏目
     */
    public static Observable<ArticleColumnsResponse> getSubmitArticleColumns(int user_id, String sign) {
        return sNewsService.getSubmitArticleColumns(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }


    /**
     * APP投稿设置-主题子栏目
     */
    public static Observable<ArticleLabelsResponse> getSubmitArticleLabels(int user_id, int theme_id, String sign) {
        return sNewsService.getSubmitArticleLabels(user_id, theme_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 确认投稿
     */
    public static Observable<INetBean> submitArticle(int user_id, int cg_id, int lianzai_id, boolean isserial,
                                                     int number, String sign, SubmitArticleBody body) {
        return sNewsService.submitArticle(user_id, cg_id, lianzai_id, isserial, number, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 连载目录
     */
    public static Observable<CatalogInfo> getCatalogue(int user_id, int serialize_id,
                                                       int pageIndex, int pageSize, String sign) {
        return sNewsService.getCatalogue(user_id, serialize_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 文章点赞/帖子点赞
     */
    public static Observable<ArticleLike> getlike(int id, int user_id, String type, String sign) {
        return sNewsService.getlike(id, user_id, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 取消文章点赞
     */
    public static Observable<ArticleLike> getOfflike(int user_id, String type, int contribute_id, String sign) {
        return sNewsService.getOfflike(user_id, type, contribute_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 单个文章详情
     */
    public static Observable<ArticleDetailsResponse> getOnePostDetail(int user_id, int contribute_id,
                                                                      int type, int topic_id, String sign) {
        return sNewsService.getOnePostDetail(user_id, contribute_id, type, topic_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取推荐的笔友会列表
     */
    public static Observable<PenpalResponse> getRecommendPenpal(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getRecommendPenpal(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 根据id获取笔友会信息
     */
    public static Observable<PenpalDetailsResponse> getPenpalDetailsById(int user_id, int penpalwill_id, String sign) {
        return sNewsService.getPenpalDetailsById(user_id, penpalwill_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取笔会帖子列表/获取笔会文章列表
     */
    public static Observable<PenpalArticleResponse> getPenpalArticles(int user_id, int penpalwill_id, int type,
                                                                      int pageIndex, int pageSize, String sign) {
        return sNewsService.getPenpalArticles(user_id, penpalwill_id, type, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 申请加入笔友会
     */
    public static Observable<INetBean> requestAddPenpal(int user_id, int penpalwill_id, String sign) {
        return sNewsService.requestAddPenpal(user_id, penpalwill_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 退出笔友会
     */
    public static Observable<INetBean> exitPenpal(int user_id, int penpalwill_id, String sign) {
        return sNewsService.exitPenpal(user_id, penpalwill_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 笔友会首页推荐帖子
     */
    public static Observable<PenpalRecommendArticleResponse> getPenpalRecommendArticles(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getPenpalRecommendArticles(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }


    /**
     * 获取用户道具卡数量
     */
    public static Observable<UserProps> getUserProps(int user_id, int propsType, String sign) {
        return sNewsService.getUserProps(user_id, propsType, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 读者推荐
     */
    public static Observable<RecommendResponse> postRecommend(int user_id, int contribute_id, int contribute_type, int recommend_type,
                                                              int pay_device, int pay_type, String sign, RecommendClass recommendClass) {
        return sNewsService.postRecommend(
                user_id, contribute_id, contribute_type,
                recommend_type, pay_device, pay_type, sign, recommendClass)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取个人推荐语列表
     */
    public static Observable<PeopleRecommendRespose> getOneRecommendMsg(int contribute_id, int contribute_type,
                                                                        int from_uid, int pageIndex, int pageSize, String sign) {
        return sNewsService.getOneRecommendMsg(contribute_id, contribute_type, from_uid, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 关键字搜索笔会/标签搜索/地区搜索
     */
    public static Observable<PenpalResponse> getPenPalListByKeyword(int user_id, String label, String penclubname,
                                                                    String district, int pageIndex, int pageSize, String sign) {
        return sNewsService.getPenPalListByKeyword(user_id, label, penclubname, district, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取更多推荐语
     */
    public static Observable<RecomendMsg> getMoreRecommendMsg(int contribute_id, int contribute_type,
                                                              int pageIndex, int pageSize, String sign) {
        return sNewsService.getMoreRecommendMsg(contribute_id, contribute_type, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 连载翻页
     */
    public static Observable<ArticleDetailsResponse> getFEPageTurn(int user_id, int serialize_id,
                                                                   int sort, int type, String sign) {
        return sNewsService.getFEPageTurn(user_id, serialize_id, sort, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取文章详情下的评论
     */
    public static Observable<CommentDetails> getcommentDetail(int user_id, int contribute_id, int Sort,
                                                              int pageIndex, int pageSize, String sign) {
        return sNewsService.getcommentDetail(user_id, contribute_id, Sort, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 帖子详情下的评论
     */
    public static Observable<CommentDetails> getPostCommentDetail(int user_id, int topic_id, int Sort,
                                                                  int pageIndex, int pageSize, String sign) {
        return sNewsService.getPostCommentDetail(user_id, topic_id, Sort, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 我的笔友会+推荐的笔友会
     */
    public static Observable<PenpalHomeResponse> getPenpalHome(int user_id, String sign) {
        return sNewsService.getPenpalHome(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 我的所有笔友会
     */
    public static Observable<PenpalResponse> getJoinedPenpal(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getJoinedPenpal(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * Ta的所有笔友会
     */
    public static Observable<PenpalResponse> getTaJoinedPenpal(int user_id, int ta_user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getTaJoinedPenpal(user_id, ta_user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取笔会信息
     */
    public static Observable<PenpalMessageResponse> getPenpalMessageById(int user_id, int penpalwill_id, String sign) {
        return sNewsService.getPenpalMessageById(user_id, penpalwill_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取笔友会公告
     */
    public static Observable<PenpalNoticeResponse> getNotice(int user_id, int penpalwill_id, String sign) {
        return sNewsService.getNotice(user_id, penpalwill_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 点击收藏/点击取消
     */
    public static Observable<INetBean> getIsCollect(int user_id, int type, int content_id, String sign) {
        return sNewsService.getIsCollect(user_id, type, content_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取笔友会标签
     */
    public static Observable<LabelResponse> getPenpalLabels(int rnd, String sign) {
        return sNewsService.getPenpalLabels(rnd, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取笔友会标签
     */
    public static Observable<INetBean> editPenpalMsg(int user_id, int penpalwill_id, String district, String sign, EditPenpalMsgBody signatureClass) {
        return sNewsService.editPenpalMsg(user_id, penpalwill_id, district, sign, signatureClass)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 文章/帖子分享
     */
    public static Observable<ShareInformation> getShareInformation(int type, int contribute_id, int type_id,
                                                                   int user_id, int penpalwill_id, String sign) {
        return sNewsService.getShareInformation(type, contribute_id, type_id, user_id, penpalwill_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 笔友会成员查看/成员管理查看
     */
    public static Observable<MemberMsgResponse> getPenpalMember(int user_id, int penpalwill_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getPenpalMember(user_id, penpalwill_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 笔友会成员查看/成员管理查看
     */
    public static Observable<INetBean> addPenpalNotice(int user_id, int penpalwill_id, String sign, AddNoticeBody body) {
        return sNewsService.addPenpalNotice(user_id, penpalwill_id, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取单个评论下的所有回复
     */
    public static Observable<CommenOneAllDetails> getOnecommentDetail(int user_id, int comment_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getOnecommentDetail(user_id, comment_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取单个留言
     */
    public static Observable<CommentDetails> getOnecomment(int user_id, int comment_id, String sign) {
        return sNewsService.getOnecomment(user_id, comment_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取我的主页 我的关注 1，我的粉丝 2 ,我的黑名单 3
     */
    public static Observable<SearchAuthorResponse> getSetUserRelationships(int user_id, int type, int page, int pageSize, String sign) {
        return sNewsService.getSetUserRelationships(user_id, type, page, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取TA的主页 我的关注 1，我的粉丝 2 ,我的黑名单 3
     */
    public static Observable<SearchAuthorResponse> getTaUserRelationships(int user_id, int ta_user_id, int type, int page, int pageSize, String sign) {
        return sNewsService.getTaUserRelationships(user_id, ta_user_id, type, page, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 文章评论/评论回复/回复回复
     */
    public static Observable<ResponseBody> postCommentOrReplyAdd(int user_id, int contribute_id, int comment_id,
                                                                 int reply_id, String sign, ContentClass contentClass) {
        return sNewsService.postCommentOrReplyAdd(user_id, contribute_id, comment_id, reply_id, sign, contentClass)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 设置/取消笔友会公告
     */
    public static Observable<INetBean> setTopPenpalNotice(int user_id, int penpalwill_id, int announCement_id, String sign) {
        return sNewsService.setTopPenpalNotice(user_id, penpalwill_id, announCement_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 删除笔友会公告
     */
    public static Observable<INetBean> deletePenpalNotice(int user_id, int penpalwill_id, int announCement_id, String sign) {
        return sNewsService.deletePenpalNotice(user_id, penpalwill_id, announCement_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 修改笔友会公告
     */
    public static Observable<INetBean> editPenpalNotice(int user_id, int announCement_id, String sign, EditNoticeBody body) {
        return sNewsService.editPenpalNotice(user_id, announCement_id, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 帖子置顶/取消置顶
     */
    public static Observable<INetBean> setTopPenpalArticle(int user_id, int topic_id, int penpalwill_id, String sign) {
        return sNewsService.setTopPenpalArticle(user_id, topic_id, penpalwill_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 帖子删除
     */
    public static Observable<INetBean> deletePenpalArticle(int user_id, int topic_id, int penpalwill_id, String sign) {
        return sNewsService.deletePenpalArticle(user_id, topic_id, penpalwill_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 帖子推荐到广场/取消推荐
     */
    public static Observable<INetBean> pushPiazza(int user_id, int topic_id, int penpalwill_id, int type, String sign) {
        return sNewsService.pushPiazza(user_id, topic_id, penpalwill_id, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 笔友会申请审核(获取申请加入笔友会的成员)
     */
    public static Observable<PenpalJoinVerifyResponse> getJoinRequestMember(int user_id, int penpalwill_id, String auditState,
                                                                            int pageIndex, int pageSize, String sign) {
        return sNewsService.getJoinRequestMember(user_id, penpalwill_id, auditState, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 笔会申请通过/拒绝
     */
    public static Observable<INetBean> isAgreeJoinPenpal(int user_id, int penpalwill_id, String auditState,
                                                         int apply_userid, String sign) {
        return sNewsService.isAgreeJoinPenpal(user_id, penpalwill_id, auditState, apply_userid, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 设置加入笔友会是否需要审批
     */
    public static Observable<INetBean> joinPenpalSwitch(int user_id, int penpalwill_id, String sign) {
        return sNewsService.joinPenpalSwitch(user_id, penpalwill_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 评论点赞（任何评论）
     * user_id
     * 当前用户ID
     * type
     * 1文章，2帖子
     * obj_id
     * 文章ID或者帖子ID
     * comment_id
     * 当前评论ID
     */
    public static Observable<INetBean> getCommentlike(int user_id, int type, int obj_id, int comment_id, String sign) {
        return sNewsService.getCommentlike(user_id, type, obj_id, comment_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 取消评论点赞（任何评论）
     * 点赞类型(post帖子，article文章)
     */
    public static Observable<INetBean> cancelCommentLike(int user_id, String type, int contribute_id, String sign) {
        return sNewsService.cancelCommentLike(user_id, type, contribute_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 评论点赞（任何评论）
     */
    public static Observable<INetBean> setPostIsPublic(int user_id, int comment_id, String sign) {
        return sNewsService.setPostIsPublic(user_id, comment_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 判断当前用户是否有笔友会
     */
    public static Observable<INetBean> userIsHasPenpal(int user_id, String sign) {
        return sNewsService.userIsHasPenpal(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 选择发帖对象发帖
     */
    public static Observable<INetBean> postSelectPenpal(int user_id, int penpalwill_id, String sign, SubmitPostBody contentClass) {
        return sNewsService.postSelectPenpal(user_id, penpalwill_id, sign, contentClass)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取用户资料
     */
    public static Observable<UserInfo> getUserInfo(int user_id, String sign) {
        return sNewsService.getUserInfo(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 完善用户基本信息
     */
    public static Observable<INetBean> postUserSetPerfectInfo(int user_id, String pseudonym, String sex,
                                                              String birthday, String city, String sign, UpLoadFile upLoadFile) {
        return sNewsService.postUserSetPerfectInfo(user_id, pseudonym, sex, birthday, city, sign, upLoadFile)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }


    /**
     * 扫描二维码登陆
     */
    public static Observable<INetBean> sweepQrCodeLogin(int user_id, String uip, String sign) {
        return sNewsService.sweepQrCodeLogin(user_id, uip, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 创建笔友会
     */
    public static Observable<INetBean> createPenpal(int user_id, String district, String sign, EditPenpalMsgBody body) {
        return sNewsService.createPenpal(user_id, district, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取榕树叶充值套餐列表
     */
    public static Observable<PaySetMeal> getRongShuLeaf(int rnd, String sign) {
        return sNewsService.getRongShuLeaf(rnd, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取我的卡包
     */
    public static Observable<CardBagInfo> getMyProps(int user_id, String sign) {
        return sNewsService.getMyProps(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取充值/消费记录
     */
    public static Observable<PayDetail> getTopUpRecord(int user_id, String type,
                                                       int page, int pagesize, String sign) {
        return sNewsService.getTopUpRecord(user_id, type, page, pagesize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 创建/加入(创建笔会等级判断)
     */
    public static Observable<INetBean> createPenpalPermission(int user_id, String sign) {
        return sNewsService.createPenpalPermission(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取分享url
     */
    public static Observable<ShareInformation> getShareUrl(int user_id, String sign) {
        return sNewsService.getShareUrl(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 我的帖子
     */
    public static Observable<PenpalArticleResponse> getMyForum(int user_id, int page, int pagesize, String sign) {
        return sNewsService.getMyForum(user_id, page, pagesize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 我的推荐
     */
    public static Observable<Recommend> getMyRecommend(int user_id, int page, int pagesize, String sign) {
        return sNewsService.getMyRecommend(user_id, page, pagesize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 笔友会成员管理操作(升级为副会长/降级为普通成员/踢出/移交笔友会)
     * (Upgrade升级为副会长，demotion 降级为普通成员，Kick踢出，handover 移交)
     */
    public static Observable<INetBean> penpalMemberOption(int user_id, int penpalwill_id, int Position_user_id, String OperatelType, String sign) {
        return sNewsService.penpalMemberOption(user_id, penpalwill_id, Position_user_id, OperatelType, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 笔友会搜索帖子列表/笔友会搜索文章列表
     */
    public static Observable<PenpalArticleResponse> penpalSearchArticleList(int user_id, int penpalwill_id, String searchWhere,
                                                                            int type, int pageIndex, int pageSize, String sign) {
        return sNewsService.penpalSearchArticleList(user_id, penpalwill_id, searchWhere, type, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 我的分享-文章列表
     */
    public static Observable<ArticleListResponse> getMyShareArticle(int user_id, int type, int page, int pagesize, String sign) {
        return sNewsService.getMyShareArticle(user_id, type, page, pagesize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 我的分享-帖子列表
     */
    public static Observable<PenpalArticleResponse> getMySharePost(int user_id, int type, int page, int pagesize, String sign) {
        return sNewsService.getMySharePost(user_id, type, page, pagesize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 我的收藏
     */
    public static Observable<EnshrineInfo> getMyCollect(int user_id, int type, int pageIndex, int pageSize, String sign) {
        return sNewsService.getMyCollect(user_id, type, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 我的浏览记录
     */
    public static Observable<TodayRecord> getMyBrowsingHistory(int user_id, int type, int page, int pagesize, String sign) {
        return sNewsService.getMyBrowsingHistory(user_id, type, page, pagesize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 修改密码
     */
    public static Observable<ResetPassword> postUserSetPwd(int user_id, String code, String sign, UpdateUserClass updateUserClass) {
        return sNewsService.postUserSetPwd(user_id, code, sign, updateUserClass)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 绑定手机号码
     */
    public static Observable<INetBean> getBindingMobile(int user_id, String mobile, String sms_code, String key, String sign) {
        return sNewsService.getBindingMobile(user_id, mobile, sms_code, key, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 更换手机号码---验证验证码
     */
    public static Observable<INetBean> getGengHuanMobile(int user_id, String mobile, String sms_code, String sign) {
        return sNewsService.getGengHuanMobile(user_id, mobile, sms_code, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取隐私设置/消息推送设置
     */
    public static Observable<PrivacyInfo> getPrivacy(int user_id, String sign) {
        return sNewsService.getPrivacy(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 隐私设置
     */
    public static Observable<INetBean> getSetPrivacy(int user_id, int recommend, int followMe, int sendOffline,
                                                     int browseHomePage, int browseMypen, int joinMypen, String sign) {
        return sNewsService.getSetPrivacy(user_id, recommend, followMe, sendOffline, browseHomePage, browseMypen, joinMypen, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 消息推送设置
     */
    public static Observable<INetBean> getMsgPush(int user_id, int push_zan, int push_pinglun, int push_aite,
                                                  int push_wenzhang, int push_send, String sign) {
        return sNewsService.getMsgPush(user_id, push_zan, push_pinglun, push_aite, push_wenzhang, push_send, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 关于
     */
    public static Observable<AboutUs> getAbout(int rnd, String sign) {
        return sNewsService.getAbout(rnd, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 退出登录
     */
    public static Observable<INetBean> getLogOut(int user_id, String sign) {
        return sNewsService.getLogOut(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 删除用户已读的文章
     */
    public static Observable<INetBean> deleteRead(int user_id, int contribute_id, int contribute_type, String sign) {
        return sNewsService.deleteRead(user_id, contribute_id, contribute_type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 帖子详情
     */
    public static Observable<PostDetailsResponse> postDetails(int user_id, int topic_id, String sign) {
        return sNewsService.postDetails(user_id, topic_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 帖子评论删除/评论回复删除/回复回复删除
     */
    public static Observable<ResponseBody> postComment(int user_id, int penpalwill_id, int topic_id, int comment_id,
                                                       int reply_id, String sign, PostCommentBody body) {
        return sNewsService.postComment(user_id, penpalwill_id, topic_id, comment_id, reply_id, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * APP获取回收站文章名字列表
     */
    public static Observable<RecyclerStationInfo> getRecycleBinContribute(int user_id, String sign) {
        return sNewsService.getRecycleBinContribute(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * APP恢复已删除的文章
     */
    public static Observable<INetBean> getRecoverContribute(int user_id, int contribute_id, String sign) {
        return sNewsService.getRecoverContribute(user_id, contribute_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * APP彻底删除文章
     */
    public static Observable<INetBean> getShiftDeleteContribute(int user_id, int contribute_id, String sign) {
        return sNewsService.getShiftDeleteContribute(user_id, contribute_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * App获取文集名字列表
     */
    public static Observable<Article> getAppSerial(int user_id, String isSerial, int pageIndex, int pageSize, String sign) {
        return sNewsService.getAppSerial(user_id, isSerial, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取用户所有文章列表
     */
    public static Observable<CollectedArticle> getUserAritcle(int user_id, int type, int pageIndex, int pageSize, String sign) {
        return sNewsService.getUserAritcle(user_id, type, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取Ta所有文章列表
     */
    public static Observable<ArticleListResponse> getTaAritcle(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getTaAritcle(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }


    /**
     * APP修改文集
     */
    public static Observable<INetBean> getUpdateSerial(int user_id, int serial_id, String serial_name, String sign) {
        return sNewsService.getUpdateSerial(user_id, serial_id, serial_name, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * APP创建文集
     */
    public static Observable<INetBean> getAddSerial(int user_id, String serial_name, String isSerial, String sign) {
        return sNewsService.getAddSerial(user_id, serial_name, isSerial, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * APP删除文集
     */
    public static Observable<INetBean> getDeleteSerial(int user_id, int serial_id, String sign) {
        return sNewsService.getDeleteSerial(user_id, serial_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * APP获取文集下的文章列表
     */
    public static Observable<CollectedArticle> getMyArticle(int user_id, int serialize_id, int type,
                                                            int page, int pagesize, String sign) {
        return sNewsService.getMyArticle(user_id, serialize_id, type, page, pagesize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * APP删除文章
     */
    public static Observable<INetBean> getDeleteContribute(int user_id, int contribute_id, String sign) {
        return sNewsService.getDeleteContribute(user_id, contribute_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }


    /**
     * 我的私信
     */
    public static Observable<DirectMessage> getMyPrivateMessage(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getMyPrivateMessage(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取我的消息页面的未读信息数
     */
    public static Observable<MessageInfo> getMsgCount(int user_id, String sign) {
        return sNewsService.getMsgCount(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }


    /**
     * @ 我的消息
     */
    public static Observable<AtMineMessage> getAtMyMsg(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getAtMyMsg(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 我的系统消息
     */
    public static Observable<SystemMessage> getSystemMessage(int user_id, int page, int pagesize, String sign) {
        return sNewsService.getSystemMessage(user_id, page, pagesize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 点击@我消息阅读
     */
    public static Observable<INetBean> getSetReadAtMyMsg(int AtMyMsg_id, String sign) {
        return sNewsService.getSetReadAtMyMsg(AtMyMsg_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 私信消息列
     */
    public static Observable<DirectChat> getReceiveMessage(int send_userid, int receive_userid, int pageIndex, int pageSize, String sign) {
        return sNewsService.getReceiveMessage(send_userid, receive_userid, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 发送私信消息
     */
    public static Observable<INetBean> postSendMessage(int send_userid, int receive_userid, String sign, sixinClass sixinClass) {
        return sNewsService.postSendMessage(send_userid, receive_userid, sign, sixinClass)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }


    /**
     * 获取第三方账号绑定信息和实名认证信息
     */
    public static Observable<ThirdPartyInfo> getThirdParty(int user_id, String sign) {
        return sNewsService.getThirdParty(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 实名认证
     */
    public static Observable<INetBean> getRealNameAuthentication(int user_id, String id_card, String name, String sign) {
        return sNewsService.getRealNameAuthentication(user_id, id_card, name, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 第三方账户绑定
     */
    public static Observable<INetBean> getBindingQQWechatWeiBo(int user_id, int type, String open, String nickname, String sign) {
        return sNewsService.getBindingQQWechatWeiBo(user_id, type, open, nickname, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 第三方账户解绑
     */
    public static Observable<INetBean> getUnlinkQQWechatWeiBo(int user_id, int type, String sign) {
        return sNewsService.getUnlinkQQWechatWeiBo(user_id, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 第三方账户登陆
     */
    public static Observable<PasswordLogin> postQQWechatWeiBoLog(int type, String registrationid, String sign, ThirdPartyClass partyClass) {
        return sNewsService.postQQWechatWeiBoLog(type, registrationid, sign, partyClass)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 完善标签
     */
    public static Observable<INetBean> postPerfectLable(int user_id, String sign, List<Integer> integers) {
        return sNewsService.postPerfectLable(user_id, sign, integers)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 浏览
     */
    public static Observable<INetBean> getbrowse(int user_id, int contribute_id, int type, String code, String sign) {
        return sNewsService.getbrowse(user_id, contribute_id, type, code, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 离开文章时填写对文章的行为记录
     */
    public static Observable<INetBean> getLogUserBehavior(int user_id, int contribute_id, int ScrollingPercentMax, int TotalStayTime, String sign) {
        return sNewsService.getLogUserBehavior(user_id, contribute_id, ScrollingPercentMax, TotalStayTime, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 每日首次登陆APP获取经验
     */
    public static Observable<INetBean> getFirstLogInExp(int user_id, String sign) {
        return sNewsService.getFirstLogInExp(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 点击充值生成订单
     */
    public static Observable<OrderInfo> getTopUp(int user_id, int pay_device, int pay_way, int money, int LeafNumber, String sign) {
        return sNewsService.getTopUp(user_id, pay_device, pay_way, money, LeafNumber, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取我是否收藏
     */
    public static Observable<UserCollect> getIsShouChang(int user_id, int contribute_id, int type, String sign) {
        return sNewsService.getIsShouChang(user_id, contribute_id, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取用户是否把我拉黑
     */
    public static Observable<IsAtUserBlackResponse> isAtUserBlack(int user_id, int user_id_to, String sign) {
        return sNewsService.isAtUserBlack(user_id, user_id_to, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 编辑日签
     */
    public static Observable<INetBean> editDaySign(int signMaking_id, int user_id, String sign, MakeDaySignBody body) {
        return sNewsService.editDaySign(signMaking_id, user_id, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 制作日签
     */
    public static Observable<INetBean> makeDaySign(int user_id, String sign, MakeDaySignBody body) {
        return sNewsService.makeDaySign(user_id, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取账号信息
     */
    public static Observable<AccountInformation> getAccountModel(int user_id, String sign) {
        return sNewsService.getAccountModel(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取日签和制作库
     */
    public static Observable<DaySignListResponse> getDaySignList(int user_id, int type, int pageIndex, int pageSize, String sign, MakeDaySignBody body) {
        return sNewsService.getDaySignList(user_id, type, pageIndex, pageSize, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取文章属性
     */
    public static Observable<ArticleAttribute> getArticleAttribute(int user_id, int contribute_id, String sign) {
        return sNewsService.getArticleAttribute(user_id, contribute_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取日签详情
     * type 1制作，2日签
     * obj_id 当前制作日签ID
     */
    public static Observable<DaySignDetailsResponse> getDaySignInfo(int type, int obj_id, int user_id, String sign) {
        return sNewsService.getDaySignInfo(type, obj_id, user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取日签详情
     */
    public static Observable<DaySignInfo> getDaySign(int user_id, String sign) {
        return sNewsService.getDaySign(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }


    /**
     * 日签点赞
     */
    public static Observable<INetBean> GetDaySignLike(int user_id, int dailyCheckId, int type, String sign) {
        return sNewsService.GetDaySignLike(user_id, dailyCheckId, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 查看签到
     */
    public static Observable<SignListResponse> getSelectSign(int user_id, String sign) {
        return sNewsService.getSelectSign(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 每日签到/补签
     *
     * @param user_id
     * @param remark  0默认正常 2补签
     * @param sign
     * @param body
     * @return
     */
    public static Observable<SignDayResponse> postSignIn(int user_id, int remark, String sign, SignInBody body) {
        return sNewsService.postSignIn(user_id, remark, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 删除私信
     */
    public static Observable<INetBean> getDeletePrivatechat(int send_userid, int receive_userid, String sign) {
        return sNewsService.getDeletePrivatechat(send_userid, receive_userid, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 删除@我的/系统消息
     */
    public static Observable<INetBean> getDeleteMsg(int obj_id, int type, String sign) {
        return sNewsService.getDeleteMsg(obj_id, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 查询实名认证信息
     */
    public static Observable<INetBean> getSelectRealNameAuthentication(int user_id, String sign) {
        return sNewsService.getSelectRealNameAuthentication(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 申请加V认证
     */
    public static Observable<INetBean> postVipAuthentication(int user_id, String sign, PostVipAuthentication authentication) {
        return sNewsService.postVipAuthentication(user_id, sign, authentication)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取草稿内容
     */
    public static Observable<DraftResponse> getDraft(int contribute_id, String sign) {
        return sNewsService.getDraft(contribute_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 连载文集(列表)
     */
    public static Observable<SerialListResponse> getSerialList(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getSerialList(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())

                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 连载文集目录(列表)
     */
    public static Observable<SerialChapterListResponse> getSerialChapterList(int user_id, int serialize_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getSerialChapterList(user_id, serialize_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 连载文集目录(列表)
     */
    public static Observable<INetBean> deleteDaySign(int user_id, String signMakingIdStr, String sign) {
        return sNewsService.deleteDaySign(user_id, signMakingIdStr, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 静默登陆
     */
    public static Observable<INetBean> getUserQuiesceLogin(int user_id, String registrationid, String sign) {
        return sNewsService.getUserQuiesceLogin(user_id, registrationid, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * APP移动文章
     */
    public static Observable<INetBean> getMoveContribute(int user_id, int contribute_id, int serial_id, String sign) {
        return sNewsService.getMoveContribute(user_id, contribute_id, serial_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 点赞消息
     */
    public static Observable<GiveLikeMessage> getLikeMsg(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getLikeMsg(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * APP移动文章
     */
    public static Observable<EventListResponse> getEvents(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getEvents(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 文章评论删除/回复删除
     */
    public static Observable<INetBean> getCommentOrReplyDelete(int user_id, int contribute_id, int comment_id, int reply_id, String sign) {
        return sNewsService.getCommentOrReplyDelete(user_id, contribute_id, comment_id, reply_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 帖子评论删除/帖子回复删除
     */
    public static Observable<INetBean> postDeleteComment(int user_id, int topic_id, int comment_id, int reply_id, String sign) {
        return sNewsService.postDeleteComment(user_id, topic_id, comment_id, reply_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 检测更新
     */
    public static Observable<VersionUpdateResponse> checkUpgrade(int type, String version, String sign) {
        return sNewsService.checkUpgrade(type, version, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 文章点赞用户列表
     */
    public static Observable<SearchAuthorResponse> getLikeUserList(int user_id, int contribute_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getLikeUserList(user_id, contribute_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取有声文章列表
     */
    public static Observable<AudiobookListResponse> GetAudioArticlesList(int user_id, String sign) {
        return sNewsService.GetAudioArticlesList(user_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取有声文章详情
     */
    public static Observable<AudiobookDetailsResponse> GetAudioArticlesModel(int user_id, int audioId, String sign) {
        return sNewsService.GetAudioArticlesModel(user_id, audioId, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取有声文章评论列表
     */
    public static Observable<CommentDetails> getAudioArticleComment(int user_id, int audio_id, int Sort, int pageIndex, int pageSize, String sign) {
        return sNewsService.getAudioArticleComment(user_id, audio_id, Sort, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 有声文章评论/评论回复/回复回复
     */
    public static Observable<ResponseBody> audiobookPostCommentOrReplyAdd(int user_id, int audioId, int comment_id,
                                                                          int reply_id, String sign, PostCommentBody body) {
        return sNewsService.audiobookPostCommentOrReplyAdd(user_id, audioId, comment_id, reply_id, sign, body)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 有声文章评论/评论回复 删除
     */
    public static Observable<INetBean> audiobookCommentOrReplyDelete(int user_id, int audioId, int comment_id,
                                                                     int reply_id, String sign) {
        return sNewsService.audiobookCommentOrReplyDelete(user_id, audioId, comment_id, reply_id, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 评论消息
     */
    public static Observable<CommentMeMessage> getCommentMeMessage(int user_id, int pageIndex, int pageSize, String sign) {
        return sNewsService.getCommentMeMessage(user_id, pageIndex, pageSize, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 点击私信/@我的/文章评论消息，标记全部已读
     */
    public static Observable<INetBean> GetMsgAllRead(int user_id, int type, String sign) {
        return sNewsService.GetMsgAllRead(user_id, type, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 点击文章评论消息阅读
     */
    public static Observable<INetBean> GetSetReadCommentMsg(int commentId, String sign) {
        return sNewsService.GetSetReadCommentMsg(commentId, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取我的文集里不同文章状态的数量
     */
    public static Observable<CollectedWorkStatusCount> getStatusCount(int userId, int serializeId, String sign) {
        return sNewsService.getStatusCount(userId, serializeId, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    /**
     * 获取开屏广告
     */
    public static Observable<AdvertResponse> getOpenAD(int random, String sign) {
        return sNewsService.getOpenAD(random, sign)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }
}
